package cn.stylefeng.guns.modular.tao.api;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import javax.servlet.http.HttpServletRequest;
import javax.xml.parsers.DocumentBuilderFactory;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;



    public class PayUtils {
        public PayUtils() {
        }

        public static String sign(String text, String key, String input_charset) {
            text = text + "&key=" + key;
            return DigestUtils.md5Hex(getContentBytes(text, input_charset));
        }

        public static boolean verify(String text, String sign, String key, String input_charset) {
            text = text + key;
            String mysign = DigestUtils.md5Hex(getContentBytes(text, input_charset));
            return mysign.equals(sign);
        }

        public static byte[] getContentBytes(String content, String charset) {
            if (charset != null && !"".equals(charset)) {
                try {
                    return content.getBytes(charset);
                } catch (UnsupportedEncodingException var3) {
                    throw new RuntimeException("MD5签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
                }
            } else {
                return content.getBytes();
            }
        }

        private static boolean isValidChar(char ch) {
            if ((ch < '0' || ch > '9') && (ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
                return ch >= 19968 && ch <= 32767 ;
            } else {
                return true;
            }
        }

        public static Map<String, String> paraFilter(Map<String, String> sArray) {
            Map<String, String> result = new HashMap();
            if (sArray != null && sArray.size() > 0) {
                Iterator var3 = sArray.keySet().iterator();

                while(var3.hasNext()) {
                    String key = (String)var3.next();
                    String value = (String)sArray.get(key);
                    if (value != null && !value.equals("") && !key.equalsIgnoreCase("sign") && !key.equalsIgnoreCase("sign_type")) {
                        result.put(key, value);
                    }
                }

                return result;
            } else {
                return result;
            }
        }

        public static String createLinkString(Map<String, String> params) {
            List<String> keys = new ArrayList(params.keySet());
            Collections.sort(keys);
            String prestr = "";

            for(int i = 0; i < keys.size(); ++i) {
                String key = (String)keys.get(i);
                String value = (String)params.get(key);
                if (i == keys.size() - 1) {
                    prestr = prestr + key + "=" + value;
                } else {
                    prestr = prestr + key + "=" + value + "&";
                }
            }

            return prestr;
        }

        public static String httpRequest(String requestUrl, String requestMethod, String outputStr) {
            StringBuffer buffer = null;

            try {
                URL url = new URL(requestUrl);
                HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                conn.setRequestMethod(requestMethod);
                conn.setDoOutput(true);
                conn.setDoInput(true);
                conn.connect();
                if (outputStr != null) {
                    OutputStream os = conn.getOutputStream();
                    os.write(outputStr.getBytes("utf-8"));
                    os.close();
                }

                InputStream is = conn.getInputStream();
                InputStreamReader isr = new InputStreamReader(is, "utf-8");
                BufferedReader br = new BufferedReader(isr);
                buffer = new StringBuffer();
                String line = null;

                while((line = br.readLine()) != null) {
                    buffer.append(line);
                }

                br.close();
            } catch (Exception var10) {
                var10.printStackTrace();
            }

            return buffer.toString();
        }

        public static String urlEncodeUTF8(String source) {
            String result = source;

            try {
                result = URLEncoder.encode(source, "UTF-8");
            } catch (UnsupportedEncodingException var3) {
                var3.printStackTrace();
            }

            return result;
        }

        public static Map doXMLParse(String strxml) throws Exception {
            if (strxml != null && !"".equals(strxml)) {
                try {
                    Map<String, String> data = new HashMap();
                    DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
                    documentBuilderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
                    documentBuilderFactory.setFeature("http://xml.org/sax/features/external-general-entities", false);
                    documentBuilderFactory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
                    documentBuilderFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
                    documentBuilderFactory.setFeature("http://javax.xml.XMLConstants/feature/secure-processing", true);
                    documentBuilderFactory.setXIncludeAware(false);
                    documentBuilderFactory.setExpandEntityReferences(false);
                    InputStream stream = new ByteArrayInputStream(strxml.getBytes("UTF-8"));
                    Document doc = documentBuilderFactory.newDocumentBuilder().parse(stream);
                    doc.getDocumentElement().normalize();
                    NodeList nodeList = doc.getDocumentElement().getChildNodes();

                    for(int idx = 0; idx < nodeList.getLength(); ++idx) {
                        Node node = nodeList.item(idx);
                        if (node.getNodeType() == 1) {
                            Element element = (Element)node;
                            data.put(element.getNodeName(), element.getTextContent());
                        }
                    }

                    try {
                        stream.close();
                    } catch (Exception var9) {
                    }

                    return data;
                } catch (Exception var10) {
                    throw var10;
                }
            } else {
                return null;
            }
        }

        public static String getChildrenText(List children) {
            StringBuffer sb = new StringBuffer();
            if (!children.isEmpty()) {
                Iterator it = children.iterator();

                while(it.hasNext()) {
                    org.jdom2.Element e = (org.jdom2.Element)it.next();
                    String name = e.getName();
                    String value = e.getTextNormalize();
                    List list = e.getChildren();
                    sb.append("<" + name + ">");
                    if (!list.isEmpty()) {
                        sb.append(getChildrenText(list));
                    }

                    sb.append(value);
                    sb.append("</" + name + ">");
                }
            }

            return sb.toString();
        }

        public static InputStream String2Inputstream(String str) {
            return new ByteArrayInputStream(str.getBytes());
        }

        public static String getRandomStringByLength(int length) {
            String base = "abcdefghijklmnopqrstuvwxyz0123456789";
            Random random = new Random();
            StringBuffer sb = new StringBuffer();

            for(int i = 0; i < length; ++i) {
                int number = random.nextInt(base.length());
                sb.append(base.charAt(number));
            }

            return sb.toString();
        }

        public static String getIpAddr(HttpServletRequest request) {
            String ip = request.getHeader("X-Forwarded-For");
            if (StringUtils.isNotEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)) {
                int index = ip.indexOf(",");
                return index != -1 ? ip.substring(0, index) : ip;
            } else {
                ip = request.getHeader("X-Real-IP");
                return StringUtils.isNotEmpty(ip) && !"unKnown".equalsIgnoreCase(ip) ? ip : request.getRemoteAddr();
            }
        }
    }


